import { useState, useEffect, useCallback, useRef } from 'react';
import { useNavigate } from 'react-router-dom';
import { request } from '../api/request';
import { getVisitorUuid } from '../utils/userUtils';
import { deleteChatHistory, refreshChatHistory } from '../api/chatService';
import { io, Socket } from 'socket.io-client';

// 🔧 扩展Window接口
declare global {
  interface Window {
    chatLoadingCompleted?: boolean;
  }
}

// 获取WebSocket URL从环境变量，如果不存在则使用默认值
const WEBSOCKET_URL = import.meta.env.VITE_NODE_API_BASE_URL || 'http://127.0.0.1:3000';

// 图片URL优化函数，添加OSS压缩参数
const optimizeImageUrl = (url: string, width: number = 500): string => {
  if (!url) return '';

  // 如果已经包含了resize参数，直接返回
  if (url.includes('x-oss-process=image/resize')) return url;

  // 如果是网络图片，添加压缩参数
  if (/^https?:\/\//.test(url)) {
    const separator = url.includes('?') ? '&' : '?';
    return `${url}${separator}x-oss-process=image/resize,w_${width}`;
  }

  return url;
};

// 聊天历史项接口
export interface ChatHistoryItem {
  id: string;
  name: string;
  avatar: string;
  lastMessage?: string;
  timestamp?: string | Date;
  lastMessageStatus?: number; // 未读消息状态 0/1
}

// WebSocket实例
let socket: Socket | null = null;
// 防止重复初始化
let wsInitialized = false;
// 防止重复数据加载
let isLoadingData = false;
let lastLoadTime = 0;
const LOAD_COOLDOWN = 1000; // 10秒冷却时间

// 防止重复处理WebSocket消息
let lastWebSocketUpdateTime = 0;
const WS_UPDATE_COOLDOWN = 500; // 0.5秒冷却时间，提高响应速度

// 聊天历史管理Hook
export const useChatHistoryManager = () => {
  // 从sessionStorage获取当前聊天ID
  const [currentChatId, setCurrentChatId] = useState<string | undefined>(() => {
    return sessionStorage.getItem('currentConversationId') || undefined;
  });

  // 监听sessionStorage变化
  useEffect(() => {
    const handleStorageChange = () => {
      const newId = sessionStorage.getItem('currentConversationId');
      setCurrentChatId(newId || undefined);
    };

    // 监听storage事件（跨标签页的变化）
    window.addEventListener('storage', handleStorageChange);
    
    // 定期检查sessionStorage变化（同标签页内的变化）
    const interval = setInterval(handleStorageChange, 100);

    return () => {
      window.removeEventListener('storage', handleStorageChange);
      clearInterval(interval);
    };
  }, []);

  const navigate = useNavigate();
  const [historyList, setHistoryList] = useState<ChatHistoryItem[]>([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [wsConnected, setWsConnected] = useState(false);

  // 用于防止刚删除的聊天被立即重新添加的临时黑名单
  const [recentlyDeleted, setRecentlyDeleted] = useState<Set<string>>(new Set());

  // 从API获取聊天历史列表
  const loadHistoryList = useCallback(async (forceReload = false, silent = false) => {
    try {
      // 🔧 检查全局loading完成状态，防止重复loading
      if (typeof window !== 'undefined' && window.chatLoadingCompleted && !forceReload) {
        // console.log('🛑 Chat页面loading已完成，跳过重复请求');
        return historyList;
      }

      // 🔧 重新启用冷却时间检查，避免频繁请求（允许强制重载）
      const now = Date.now();
      if (!forceReload && (isLoadingData || (now - lastLoadTime < LOAD_COOLDOWN))) {
        // console.log('🛑 数据加载冷却中，跳过请求', { 
        //   isLoadingData, 
        //   timeSinceLastLoad: now - lastLoadTime, 
        //   cooldown: LOAD_COOLDOWN 
        // });
        return historyList; // 返回当前列表而不是空数组
      }

      isLoadingData = true;
      lastLoadTime = now;

      // 🔧 只在非静默模式下显示loading UI
      if (!silent) {
        setLoading(true);
      }
      setError(null);

      // 使用封装的函数获取UUID
      const uuid = getVisitorUuid();
      if (!uuid) {
        // console.log('未找到用户UUID，跳过聊天历史加载');
        setHistoryList([]);
        isLoadingData = false;
        return [];
      }

      // console.log('🔄 开始从API获取聊天历史列表, UUID:', uuid);

      // 发起API请求
      const response = await request.get('/api/chat/Get-ChatHistory-list', {
        params: { uuid }
      });

      if (response.data.success && Array.isArray(response.data.data)) {
        // 确保每个item都带有lastMessageStatus字段
        const historyData = response.data.data.map((item: any) => ({
          ...item,
          lastMessageStatus: typeof item.lastMessageStatus === 'number' ? item.lastMessageStatus : 0
        }));
        // console.log('✅ 成功获取聊天历史列表:', historyData.length, '条记录');

        setHistoryList(historyData);
        isLoadingData = false;
        return historyData;
      } else {
        // console.warn('API返回格式异常:', response.data);
        console.error('API return format exception', response.data);
        setHistoryList([]);
        isLoadingData = false;
        return [];
      }
    } catch (error) {
      // console.error('❌ 获取聊天历史列表失败:', error);
      console.error('load chat history failed', error);
      setError('CHAT_HISTORY_LOAD_FAILED'); // 使用错误码，由调用方处理国际化
      // 出错时返回空数组，不影响用户使用
      setHistoryList([]);
      isLoadingData = false;
      return [];
    } finally {
      // 🔧 只在非静默模式下重置loading状态
      if (!silent) {
        setLoading(false);
      }
      isLoadingData = false;
    }
  }, []); // 移除historyList依赖，避免循环依赖

  // 初始化WebSocket连接
  const initWebSocket = useCallback(() => {
    if (wsInitialized && socket) {
      // console.log('🔌 WebSocket已经初始化过，跳过重复初始化');
      return;
    }

    // 如果socket存在但未标记为初始化，清理旧的连接
    if (socket) {
      // console.log('🔌 清理旧的WebSocket连接');
      socket.disconnect();
      socket = null;
    }

    // 获取用户UUID
    const uuid = getVisitorUuid();
    if (!uuid) {
      // console.warn('⚠️ 未找到用户UUID，无法初始化WebSocket连接');
      return;
    }

    // console.log('🔌 初始化WebSocket连接');
    wsInitialized = true;

    // 连接WebSocket服务器
    try {
      socket = io(WEBSOCKET_URL, {
        reconnectionAttempts: 5,
        reconnectionDelay: 1000,
        timeout: 20000,
      });

      // 连接成功事件
      socket!.on('connect', () => {
        // console.log('🔌 WebSocket连接成功! Socket ID:', socket!.id);
        setWsConnected(true);

        // 发送认证请求
        socket!.emit('authenticate', { uuid });

        // 监听认证响应
        socket!.once('authenticated', (response) => {
          if (response.success) {
            // console.log('🔐 WebSocket认证成功!');

            // 认证成功后订阅聊天历史
            socket!.emit('subscribe-chat-history', { uuid });

            // 监听订阅响应
            socket!.once('subscribed-chat-history', (subResponse) => {
              if (subResponse.success) {
                // console.log('📋 成功订阅聊天历史更新!');
              } else {
                // console.error('📋 订阅聊天历史失败:', subResponse.message);
                console.error('subscribe chat history failed', subResponse.message);
              }
            });
          } else {
            // console.error('🔐 WebSocket认证失败:', response.message);
            console.error('WebSocket authentication failed', response.message);
          }
        });
      });

      // 监听聊天历史更新（单个聊天的更新）- 优化版本：统一使用API重新获取数据
      socket!.on('chat-history-update', (data) => {
        // console.log('📨 收到单个聊天历史更新:', data);

        // 🔧 优化：单个聊天更新也统一触发API重新获取，确保数据一致性
        const now = Date.now();
        if (now - lastWebSocketUpdateTime < WS_UPDATE_COOLDOWN) {
          // console.log('🚫 单个聊天更新冷却中，跳过处理');
          return;
        }
        lastWebSocketUpdateTime = now;

        // console.log('📨 收到单个聊天更新，触发静默API重新获取聊天历史列表');

        // 🔧 统一发起静默 Get-ChatHistory-list 请求，避免本地数据处理的复杂性和潜在问题
        setTimeout(() => {
          loadHistoryList(true, true).then((latestHistory: ChatHistoryItem[]) => {
            // console.log('✅ 单个聊天更新触发的静默API获取完成，获取到', latestHistory.length, '条最新记录');

            // 使用 setTimeout 避免在渲染过程中触发状态更新
            setTimeout(() => {
              // 根据实际API数据更新红点状态
              const unreadItems = latestHistory.filter((item: ChatHistoryItem) => item.lastMessageStatus === 1);
              if (unreadItems.length > 0) {
                // console.log(`🔴 单个更新后API确认有 ${unreadItems.length} 条未读消息`);
                window.dispatchEvent(new CustomEvent('chat-unread-update', {
                  detail: { unreadItems, timestamp: Date.now(), source: 'single-chat-api-refresh' }
                }));
              } else {
                // console.log('✅ 单个更新后API确认没有未读消息，清除红点');
                window.dispatchEvent(new CustomEvent('chat-unread-clear', {
                  detail: { timestamp: Date.now(), source: 'single-chat-api-refresh' }
                }));
              }

              // 通知其他组件数据已更新
              window.dispatchEvent(new CustomEvent('chat-history-list-refreshed', {
                detail: { timestamp: Date.now(), latestHistory, source: 'single-chat-api-refresh' }
              }));
            }, 100);
          }).catch((err: any) => {
            // console.error('❌ 单个聊天更新触发的API重新获取失败:', err);
            console.error('single chat update triggered API refresh failed', err);
          });
        }, 50); // 短暂延迟，避免频繁触发
      });

      // 监听聊天历史列表更新 - 优化版本：统一使用API重新获取数据
      socket!.on('chat-history-list-update', (data) => {
        // console.log('📋 收到聊天历史列表更新:', data);

        // 🔧 优化：无论WebSocket数据结构如何，都统一触发API重新获取
        // 这样确保数据始终以后端为准，避免数据不一致问题
        const now = Date.now();
        if (now - lastWebSocketUpdateTime < WS_UPDATE_COOLDOWN) {
          // console.log('🚫 WebSocket更新冷却中，跳过重复处理');
          return;
        }
        lastWebSocketUpdateTime = now;

        // console.log('🔄 收到WebSocket事件，触发静默API重新获取聊天历史列表');

        // 🔧 统一发起静默 Get-ChatHistory-list 请求（避免显示loading和页面刷新）
        loadHistoryList(true, true).then((latestHistory: ChatHistoryItem[]) => {
          // console.log('✅ WebSocket触发的静默API获取完成，获取到', latestHistory.length, '条最新记录');
          
          // 🔧 确保数据更新后触发ChatHistoryList组件的无感渲染
          // 由于loadHistoryList已经通过setHistoryList更新了状态，ChatHistoryList会自动重新渲染

          // 使用 setTimeout 避免在渲染过程中触发状态更新
          setTimeout(() => {
            // 根据实际API返回的数据更新红点状态
            const unreadItems = latestHistory.filter((item: ChatHistoryItem) => item.lastMessageStatus === 1);
            if (unreadItems.length > 0) {
              // console.log(`🔴 API确认有 ${unreadItems.length} 条未读消息`);

              // 触发红点更新事件
              window.dispatchEvent(new CustomEvent('chat-unread-update', {
                detail: { unreadItems, timestamp: Date.now(), source: 'websocket-api-refresh' }
              }));
            } else {
              // console.log('✅ API确认没有未读消息，清除所有红点');
              // 没有未读消息时，发送清除红点事件
              window.dispatchEvent(new CustomEvent('chat-unread-clear', {
                detail: { timestamp: Date.now(), source: 'websocket-api-refresh' }
              }));
            }

            // 通知其他组件数据已更新（可选，用于其他组件监听）
            window.dispatchEvent(new CustomEvent('chat-history-list-refreshed', {
              detail: { timestamp: Date.now(), latestHistory, source: 'websocket-api-refresh' }
            }));
          }, 100); // 延迟100ms，避免渲染冲突
        }).catch((err: any) => {
          // console.error('❌ WebSocket触发的API重新获取失败:', err);
          console.error('WebSocket triggered API refresh failed', err);
        });
      });

      // 错误处理
      socket!.on('connect_error', (error) => {
        // console.error('🔌 WebSocket连接错误:', error);
        console.error('WebSocket connection error', error);
        setWsConnected(false);
      });

      socket!.on('error', (error) => {
        // console.error('🔌 Socket错误:', error);
        console.error('Socket error', error);
      });

      socket!.on('disconnect', (reason) => {
        // console.log('🔌 WebSocket断开连接, 原因:', reason);
        setWsConnected(false);
      });

    } catch (error) {
      // console.error('🔌 创建WebSocket连接失败:', error);
      console.error('create WebSocket connection failed', error);
      wsInitialized = false;
    }

    // 添加页面卸载事件，确保在用户关闭页面前断开连接
    window.addEventListener('beforeunload', () => {
      if (socket && socket.connected) {
        // console.log('🔌 页面卸载前断开WebSocket连接');
        socket.disconnect();
      }
    });

  }, []); // 移除recentlyDeleted依赖



  // 废弃原有的localStorage保存函数，现在数据来自服务器
  const saveHistoryList = useCallback((list: ChatHistoryItem[]) => {
    // 不再保存到localStorage，只更新本地状态
    setHistoryList(list);
  }, []);

  // 添加或更新聊天历史项 - 现在只更新本地状态，不保存到localStorage
  const addOrUpdateHistoryItem = useCallback((item: ChatHistoryItem) => {
    // 检查是否在删除黑名单中
    if (recentlyDeleted.has(item.id)) {
      // console.log('🛑 该聊天在删除黑名单中，跳过添加或更新:', item.id);
      return;
    }

    // 发起请求 添加记录到数据库
    const uuid = getVisitorUuid();
    if (uuid) {
      request.post('/api/chat/Post-ChatHistory-list', [{ ...item, lastMessage: item.lastMessage || "" }], {
        params: { uuid }
      }).then(res => {
        if (res.data.success) {
          // console.log('✅ 聊天历史项同步到数据库成功');

          // 🔧 成功后静默重新获取最新的聊天历史列表（不显示loading）
          // console.log('🔄 正在静默重新获取最新的聊天历史列表...');
          loadHistoryList(true, true).then(latestHistory => {
            // console.log('✅ 静默获取最新聊天历史列表完成:', latestHistory.length, '条记录');
          }).catch(err => {
            // console.error('❌ 重新获取聊天历史列表失败:', err);
            console.error('load chat history failed',err);
          });
        } else {
          // console.error('❌ 聊天历史项同步到数据库失败:', res.data);
          console.error('save chat history failed',res.data);
        }
      }).catch(err => {
        // console.error('❌ 聊天历史项同步到数据库出错:', err);
        console.error('save chat history failed',err);
      });
    } else {
      // console.warn('⚠️ 未找到用户UUID，跳过聊天历史项同步');
      console.error('no user uuid, save chat history failed');
    }

    setHistoryList(prev => {
      const existingIndex = prev.findIndex(h => h.id === item.id);
      let newList: ChatHistoryItem[];

      if (existingIndex >= 0) {
        // 保留lastMessageStatus
        newList = [...prev];
        newList[existingIndex] = { ...newList[existingIndex], ...item, lastMessageStatus: item.lastMessageStatus ?? newList[existingIndex].lastMessageStatus };
      } else {
        // 添加新项到开头
        newList = [item, ...prev];
      }

      return newList;
    });
  }, [recentlyDeleted, loadHistoryList]);

  // 更新最后一条消息 - 现在只更新本地状态
  const updateLastMessage = useCallback((chatId: string, lastMessage: string) => {
    setHistoryList(prev => {
      const newList = prev.map(item =>
        item.id === chatId
          ? { ...item, lastMessage, timestamp: new Date(), lastMessageStatus: item.lastMessageStatus }
          : item
      );
      // console.log('更新最后一条消息:', newList);
      return newList;
    });
  }, []);

  // 新增：更新消息状态（用于移除红点）
  const updateMessageStatus = useCallback(async (chatId: string, status: number) => {
    // 先更新本地状态，提供即时反馈
    setHistoryList(prev => {
      const newList = prev.map(item =>
        item.id === chatId
          ? { ...item, lastMessageStatus: status }
          : item
      );
      // console.log(`本地更新聊天 ${chatId} 的消息状态为: ${status}`);
      return newList;
    });

    // 🔧 延迟一小段时间后静默获取最新数据，确保数据一致性（不显示loading）
    setTimeout(() => {
      // console.log(`🔄 延迟静默刷新API数据以确保聊天 ${chatId} 状态同步`);
      loadHistoryList(true, true).then(() => {
        // console.log(`✅ 聊天 ${chatId} 状态更新后的静默API数据刷新完成`);
      }).catch(err => {
        // console.error(`❌ 聊天 ${chatId} 状态更新后的API数据刷新失败:`, err);
        console.error('load chat history failed',err);
      });
    }, 200); // 200ms延迟，既能提供即时反馈，又能确保数据同步
  }, [loadHistoryList]);

  // 选择聊天
  const selectChat = useCallback((chatId: string, replace = false) => {
    if (chatId !== currentChatId) {
      // 保存当前对话ID到sessionStorage
      sessionStorage.setItem('currentConversationId', chatId);
      navigate('/conversation', { replace });
    }
  }, [currentChatId, navigate]);

  // 重置聊天
  const resetChat = useCallback(async (chatId: string) => {
    try {
      // 获取用户UUID
      const uuid = getVisitorUuid();
      if (!uuid) {
        // console.error('❌ 未找到用户UUID，无法重置聊天历史');
        console.error('no user uuid, reset chat history failed');
        return;
      }

      // 先调用API重置聊天历史
      await refreshChatHistory(chatId, uuid);

      // API重置成功后，清除本地聊天消息历史
      localStorage.removeItem(`chat_history_${chatId}`);

      // 更新历史列表中的最后消息
      updateLastMessage(chatId, '');

      // console.log(`✅ 已重置聊天 ${chatId} 的历史记录`);

      // 如果重置的是当前聊天，刷新页面重新进入此聊天界面
      if (chatId === currentChatId) {
        window.location.reload();
      }
    } catch (error) {
      // console.error('❌ 重置聊天失败:', error);
      console.error('reset chat failed',error);
      // 可以在这里添加错误提示给用户
    }
  }, [currentChatId, updateLastMessage]);

  // 删除聊天
  const deleteChat = useCallback(async (chatId: string) => {
    try {
      // 获取用户UUID
      const uuid = getVisitorUuid();
      if (!uuid) {
        // console.error('❌ 未找到用户UUID，无法删除聊天历史');
        console.error('no user uuid, delete chat history failed');
        return;
      }

      // 先调用API删除聊天历史
      await deleteChatHistory(chatId, uuid);

      // API删除成功后，将聊天ID添加到黑名单中，防止立即重新添加
      setRecentlyDeleted(prev => new Set([...prev, chatId]));

      // 5秒后从黑名单中移除，允许重新添加
      setTimeout(() => {
        setRecentlyDeleted(prev => {
          const newSet = new Set(prev);
          newSet.delete(chatId);
          return newSet;
        });
      }, 5000);

      // 清除本地相关数据
      localStorage.removeItem(`chat_history_${chatId}`);

      // 更新本地状态，从列表中移除
      setHistoryList(prev => {
        const newList = prev.filter(item => item.id !== chatId);
        // console.log(`已删除聊天 ${chatId}，剩余聊天数量: ${newList.length}`);

        // 如果删除的是当前聊天，需要跳转
        if (chatId === currentChatId) {
          if (newList.length > 0) {
            // 找到要删除的聊天在原列表中的位置
            const deletedIndex = prev.findIndex(item => item.id === chatId);
            let nextChatId: string;

            // 优先选择被删除项的下一项，如果没有下一项则选择上一项
            if (deletedIndex < newList.length) {
              nextChatId = newList[deletedIndex].id;
            } else if (newList.length > 0) {
              nextChatId = newList[newList.length - 1].id;
            } else {
              // 理论上不会发生
              navigate('/', { replace: true });
              return newList;
            }

            // console.log(`跳转到下一个聊天: ${nextChatId}`);
            // 立即跳转，不使用setTimeout
            // 保存当前对话ID到sessionStorage
            sessionStorage.setItem('currentConversationId', nextChatId);
            navigate('/conversation', { replace: true });
          } else {
            // console.log('没有其他聊天记录，跳转到home页面');
            // 如果没有其他聊天记录了，跳转到home页面
            navigate('/', { replace: true });
          }
        }

        return newList;
      });

    } catch (error) {
      // console.error('❌ 删除聊天失败:', error);
      console.error('delete chat failed',error);
      // 可以在这里添加错误提示给用户
    }
  }, [currentChatId, navigate]);

  // 监听页面刷新事件，重新获取数据
  useEffect(() => {
    const handlePageRefreshReload = () => {
      // console.log('💬 ChatHistoryManager: 接收到页面刷新重载事件，重新获取聊天历史');

      // 清除聊天历史相关的localStorage数据
      localStorage.removeItem('chat_history_list');

      // 清除所有单独的聊天记录缓存
      Object.keys(localStorage).forEach(key => {
        if (key.startsWith('chat_history_')) {
          localStorage.removeItem(key);
        }
      });

      // 重置状态并重新加载历史列表
      setHistoryList([]);
      setError(null);
      loadHistoryList();
    };

    window.addEventListener('pageRefreshDataReload', handlePageRefreshReload);

    return () => {
      window.removeEventListener('pageRefreshDataReload', handlePageRefreshReload);
    };
  }, [loadHistoryList]);

  // 当有新的AI角色数据时，确保当前聊天在历史列表中
  const ensureCurrentChatInHistory = useCallback((aiPersonData: any) => {
    if (currentChatId && aiPersonData) {
      // 检查当前聊天是否在最近删除的黑名单中
      setRecentlyDeleted(current => {
        if (current.has(currentChatId)) {
          // console.log(`🚫 聊天 ${currentChatId} 刚被删除，跳过自动添加到历史列表`);
          return current;
        }

        // 检查当前聊天是否已在历史列表中
        setHistoryList(prev => {
          const existingItem = prev.find(item => item.id === currentChatId);
          if (!existingItem) {
            addOrUpdateHistoryItem({
              id: currentChatId,
              name: aiPersonData.username || 'AI Companion',
              avatar: optimizeImageUrl(aiPersonData.avatar || '', 500),
              timestamp: new Date()
            });
          }
          return prev;
        });

        return current;
      });
    }
  }, [currentChatId, addOrUpdateHistoryItem]);

  // 初始化时获取聊天历史列表并设置WebSocket
  useEffect(() => {
    // 1. 首先强制获取历史列表（每次进入chat页面都重新获取）
    loadHistoryList(true);

    // 2. 初始化WebSocket连接
    initWebSocket();

    // 不在组件卸载时断开WebSocket连接，保持全局连接
    // 只在页面卸载时断开，参见initWebSocket中的beforeunload事件处理
    // console.log('🔌 保持WebSocket连接，切换聊天不会断开');

    return () => {
      // 在组件卸载时也不断开WebSocket连接
      // console.log('🔌 组件卸载，保持WebSocket连接');
    };
  }, [loadHistoryList, initWebSocket]);

  return {
    historyList,
    currentChatId: currentChatId || '',
    loading,
    error,
    selectChat,
    resetChat,
    deleteChat,
    addOrUpdateHistoryItem,
    updateLastMessage,
    updateMessageStatus, // 新增：更新消息状态的函数
    ensureCurrentChatInHistory,
    refreshHistoryList: loadHistoryList, // 新增：手动刷新历史列表的函数
    loadLatestChatFromHistory: loadHistoryList, // 改为使用loadHistoryList
    wsConnected // 新增：WebSocket连接状态
  };
};